# 类型转换
# int() 转换为一个整数，只能转换由纯数字组成的字符串
a = 1.2
print(type(a)) #<class 'float'>
b = int(a)
print(b,type(b)) #<class 'int'>
print(int(1.8)) # 1 浮点型强转为整型会去掉小数点及后边的数值，只保留整数部分

b = int('123')
print(type(b)) # <class 'int'>
# 如果字符串中有数字和正负号以外的字符就会报错，正负号只能作为开头的字符，不能放在中间或者结尾

# float() 转换为一个小数
print(float(11)) #11.0
print(float(-11)) #-11.0
print(float(-11.3145)) #-11.3145

# str() 转换成字符串类型 ，任何类型都可以转换成字符串类型
n = 100
print(type(n))  #<class 'int'>
n1 = str(n)
print(type(n1)) #<class 'str'>
st = str(-1.80)
print(st,type(st)) #-1.8 <class 'str'>  float-> str会去除末位为0的小数部分
st = str(-1.000)
print(st) #-1.0
li = [1,2,3]
st = str(li)
print(st,type(st)) #[1, 2, 3] <class 'str'>

# eval() 执行一个字符串，并返回表达式的值
print(10+10) #20
print('10'+'10') #1010
print('10+10') #10+10
print(eval('10+10')) #20
print(eval('10'+'10')) #1010
# eval() 可以实现list、dict、tuple、和str之间的转换
# str->list
st1 = '[[1,2],[3,4],[5,6]]'
print(st1,type(st1))
li = eval(st1)
print(li,type(li)) #[[1, 2], [3, 4], [5, 6]] <class 'list'>

# str -> dict
st2 = "{'name':'bingbing','age':18}"
print(st2,type(st2))
li2 = eval(st2)
print(li2,type(li2)) #{'name': 'bingbing', 'age': 18} <class 'dict'>

# eval 强大但不够安全，不建议使用

# list() 将可迭代对象转换成列表
# 支持转换成list的类型：str、tuple、dict、set
# str -> list
print(list('abcdefg')) #['a', 'b', 'c', 'd', 'e', 'f', 'g']
# print(list(123456)) #报错，因为123456不是可迭代对象

# tuple->list
print(list((1,2,3,4))) #[1, 2, 3, 4]

# dict -> list
st2 = {'name':'bingbing','age':18}
print(list(st2)) #['name', 'age']
# 字典转列表，会取键名作为列表的值

# set->list
print(list({'1',2,'3',4,5})) #[2, 4, 5, '1', '3'] 集合无序，并且会先去重在转换

# 深浅拷贝
# 赋值 等于完全共享资源，一个值的改变会完全被另一个值共享，两个指向同一个地址
li = [1,2,3,4]
print("li",li)
li2 = li #将li直接赋值给li2
print("li2",li2)
li.append(5)
print("li",li)
print("li2",li2) # li 和li2 都发生了变化

# 浅拷贝
# 会创建一个新的对象，拷贝第一层的数据，嵌套层会指向原来的内存地址
import copy
li = [1,2,3,[4,5]] #定义一个嵌套列表
li2 = copy.copy(li)
print(li)
print(li2)
# 查看内存地址
print("li内存地址：",id(li))
print("li2内存地址：",id(li2))
li.append(6)
print(li)
print(li2)
# 往嵌套列表添加数据
li[3].append(6)
print(li)
print(li2) #两个嵌套地址都添加了数据6
print("li[3]内存地址：",id(li[3]))
print("li2[3]内存地址：",id(li2[3])) #浅拷贝嵌套层内存地址是一样的

# 浅拷贝有点：拷贝速度快，占用空间少，拷贝效率高

# 深拷贝
# 外层的对象和内部的元素都拷贝了一遍,数据变化只影响自身
import copy
li = [1,2,3,[4,5]]
li2 = copy.deepcopy(li)
print("li内存地址：",id(li))
print("li2内存地址：",id(li2))
li.append(6)
print(li)
print(li2)
li[3].append(7)
print("li[3]内存地址：",id(li[3]))
print("li2[3]内存地址：",id(li2[3]))
print("li",li)
print("li2",li2)

# 可变类型
# 变量对应的值可以修改，内存地址不会发生改变
li = [1,2,3,[4,5]]
print("li内存地址：",id(li))
li.append(6)
print("li内存地址：",id(li))
st2 = {'name':'bingbing','age':18}
print("st2内存地址：",id(st2))
st2['sex'] = 'nv'
print("st2内存地址：",id(st2))

set = {1,2,3,4}
print("set内存地址：",id(set))
set.remove(3)
print(set)
print("set内存地址：",id(set))

# 不可变类型：存储空间保存的数据不允许被修改，这种数据就是不可变类型，如果修改就会生成一个新的值从而分配一个新的内存空间
# 常见的不可变类型：
# 1.数值类型：int,bool,float,complex
# 2.字符串：str
# 3.元组：tuple

n = 10
print(n,id(n))
n = 20
print(n,id(n))

str = 'bingbing'
print(str,id(str))
str = 'ssssss'
print(str,id(str))

tua = (1,2,3)
print(tua,id(tua))
tua = ('a','b','c')
print(tua,id(tua))